using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Windows.Forms;
using System.Drawing;

namespace GameEditor.Common.Controls
{
    [TypeConverterAttribute(typeof(OptionsSettingTypeConverter))]
    public class TextFormatting
    {
        ContentAlignment m_alignment = ContentAlignment.MiddleLeft;
        Color m_foreColor = SystemColors.ControlText;
        Color m_backColor = Color.Transparent;
        Padding m_padding = new Padding(0, 0, 0, 0);
        public TextFormatFlags GetFormattingFlags()
        {
            TextFormatFlags flags = 0;
            switch (TextAlignment)
            {
                case ContentAlignment.TopLeft:
                    flags = TextFormatFlags.Top | TextFormatFlags.Left;
                    break;
                case ContentAlignment.TopCenter:
                    flags = TextFormatFlags.Top | TextFormatFlags.HorizontalCenter;
                    break;
                case ContentAlignment.TopRight:
                    flags = TextFormatFlags.Top | TextFormatFlags.Right;
                    break;
                case ContentAlignment.MiddleLeft:
                    flags = TextFormatFlags.VerticalCenter | TextFormatFlags.Left;
                    break;
                case ContentAlignment.MiddleCenter:
                    flags = TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter;
                    break;
                case ContentAlignment.MiddleRight:
                    flags = TextFormatFlags.VerticalCenter | TextFormatFlags.Right;
                    break;
                case ContentAlignment.BottomLeft:
                    flags = TextFormatFlags.Bottom | TextFormatFlags.Left;
                    break;
                case ContentAlignment.BottomCenter:
                    flags = TextFormatFlags.Bottom | TextFormatFlags.HorizontalCenter;
                    break;
                case ContentAlignment.BottomRight:
                    flags = TextFormatFlags.Bottom | TextFormatFlags.Right;
                    break;
            }
            return flags;
        }

        [DefaultValue(typeof(Padding), "0,0,0,0")]
        public Padding Padding
        {
            get { return m_padding; }
            set { m_padding = value; }
        }
        [DefaultValue(typeof(ContentAlignment), "MiddleLeft")]
        public ContentAlignment TextAlignment
        {
            get { return m_alignment; }
            set { m_alignment = value; }
        }
        [DefaultValue(typeof(Color), "ControlText")]
        public Color ForeColor
        {
            get { return m_foreColor; }
            set { m_foreColor = value; }
        }
        [DefaultValue(typeof(Color), "Transparent")]
        public Color BackColor
        {
            get { return m_backColor; }
            set { m_backColor = value; }
        }
        public TextFormatting()
        {
        }
        public TextFormatting(TextFormatting aCopy)
        {
            m_alignment = aCopy.m_alignment;
            m_foreColor = aCopy.m_foreColor;
            m_backColor = aCopy.m_backColor;
            m_padding = aCopy.m_padding;
        }
    }

    [TypeConverterAttribute(typeof(OptionsSettingTypeConverter))]
    public class ViewSetting
    {
        TreeListView m_owner;
        BorderStyle m_borderStyle = BorderStyle.Fixed3D;
        int m_indent = 16;
        bool m_showLine = true;
        bool m_showPlusMinus = true;
        bool m_showGridLines = true;

        [Category("Behavior")]
        [DefaultValue(typeof(int), "16")]
        public int Indent
        {
            get { return m_indent; }
            set
            {
                m_indent = value;
                m_owner.Invalidate();
            }
        }

        [Category("Behavior")]
        [DefaultValue(typeof(bool), "True")]
        public bool ShowLine
        {
            get { return m_showLine; }
            set
            {
                m_showLine = value;
                m_owner.Invalidate();
            }
        }

        [Category("Behavior")]
        [DefaultValue(typeof(bool), "True")]
        public bool ShowPlusMinus
        {
            get { return m_showPlusMinus; }
            set
            {
                m_showPlusMinus = value;
                m_owner.Invalidate();
            }
        }

        [Category("Behavior")]
        [DefaultValue(typeof(bool), "True")]
        public bool ShowGridLines
        {
            get { return m_showGridLines; }
            set
            {
                m_showGridLines = value;
                m_owner.Invalidate();
            }
        }

        [Category("Appearance")]
        [DefaultValue(typeof(BorderStyle), "None")]
        public BorderStyle BorderStyle
        {
            get { return m_borderStyle; }
            set
            {
                if (m_borderStyle != value)
                {
                    m_borderStyle = value;
                    m_owner.internalUpdateStyles();
                    m_owner.Invalidate();
                }
            }
        }

        public ViewSetting(TreeListView owner)
        {
            m_owner = owner;
        }
    }

    [TypeConverterAttribute(typeof(OptionsSettingTypeConverter))]
    public class CollumnSetting
    {
        int m_leftMargin = 5;
        int m_headerHeight = 20;
        TreeListView m_owner;
        bool columnSortEnabled=true;

        public bool ColumnSortEnabled
        {
            get
            {
                return columnSortEnabled;
            }
            set
            {
                columnSortEnabled = value;
            }
        }



        [DefaultValue(5)]
        public int LeftMargin
        {
            get { return m_leftMargin; }
            set
            {
                m_leftMargin = value;
                m_owner.Columns.RecalcVisibleColumsRect();
                m_owner.Invalidate();
            }
        }
        [DefaultValue(20)]
        public int HeaderHeight
        {
            get { return m_headerHeight; }
            set
            {
                m_headerHeight = value;
                m_owner.Columns.RecalcVisibleColumsRect();
                m_owner.Invalidate();
            }
        }
        public CollumnSetting(TreeListView owner)
        {
            m_owner = owner;
        }
    }

    [TypeConverterAttribute(typeof(OptionsSettingTypeConverter))]
    public class RowSetting
    {
        TreeListView m_owner;
        bool m_showHeader = true;
        int m_headerWidth = 15;
        int m_itemHeight = 21;
        [DefaultValue(true)]
        public bool ShowHeader
        {
            get { return m_showHeader; }
            set
            {
                if (m_showHeader == value)
                    return;
                m_showHeader = value;
                m_owner.Columns.RecalcVisibleColumsRect();
                m_owner.Invalidate();
            }
        }
        [DefaultValue(15)]
        public int HeaderWidth
        {
            get { return m_headerWidth; }
            set
            {
                if (m_headerWidth == value)
                    return;
                m_headerWidth = value;
                m_owner.Columns.RecalcVisibleColumsRect();
                m_owner.Invalidate();
            }
        }

        [Category("Behavior")]
        [DefaultValue(typeof(int), "21")]
        public int ItemHeight
        {
            get { return m_itemHeight; }
            set
            {
                m_itemHeight = value;
                m_owner.Invalidate();
            }
        }

        public RowSetting(TreeListView owner)
        {
            m_owner = owner;
        }
    }

    class OptionsSettingTypeConverter : ExpandableObjectConverter
    {
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            if (destinationType == typeof(ViewSetting))
                return true;
            if (destinationType == typeof(RowSetting))
                return true;
            if (destinationType == typeof(CollumnSetting))
                return true;
            if (destinationType == typeof(TextFormatting))
                return true;
            return base.CanConvertTo(context, destinationType);
        }
        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string) && value.GetType() == typeof(ViewSetting))
                return "(View Options)";
            if (destinationType == typeof(string) && value.GetType() == typeof(RowSetting))
                return "(Row Header Options)";
            if (destinationType == typeof(string) && value.GetType() == typeof(CollumnSetting))
                return "(Columns Options)";
            if (destinationType == typeof(string) && value.GetType() == typeof(TextFormatting))
                return "(Formatting)";
            return base.ConvertTo(context, culture, value, destinationType);
        }
    }
}
